package main

import "fmt"

//函数
func test01(arr [3]int) {
	arr[0] = 88
}

//函数
func test02(arr *[3]int) {
	fmt.Printf("arr指针的地址%p", &arr)
	(*arr)[0] = 88 //通过指针取，就能修改传入的数组
}

func main() {

	//1.数组是多个相同类型数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化
	//var arr01 [3]int
	//arr01[0] = 1
	//arr01[1] = 30
	//这里会报错
	//arr01[2] = 1.1
	//arr01[2] = 90
	//其长度是固定的，不能动态变化，否则报越界
	//arr01[3] = 890 //这里显示数组越界异常

	//fmt.Println(arr01)

	//2.var arr []int 这时arr就是一个slice切片，切片后面专门讲解，不急哈

	//3.数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用

	//4.数组创建后，如果没有赋值，有默认值(零值)
	//1)数值(整数系列，浮点数系列) => 0
	//2)字符串 => ""
	//3)布尔类型 => false
	var arr01 [3]float32
	var arr02 [3]string
	var arr03 [3]bool
	fmt.Printf("arr01=%v arr02=%v arr03=%v \n", arr01, arr02, arr03)

	//5.使用数组的步骤：
	//1)声明数组并开辟空间
	//2)给数组各个元素赋值
	//3)使用数组

	//6.数组的下标是从0开始的
	//var arr04 [3]string //0-2
	//var index int = 3
	//arr04[index] = "tom" //因为下标是 0-2，因此arr04[3]就越界

	//7.数组下标必须在指定范围内使用，否则报panic,数组越界，
	//比如 var arr [5]int 则有效下标为 0-4

	//8.go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝，数组间不会相互影响
	//arr := [3]int{11, 22, 33}
	//test01(arr)
	//fmt.Println("main arr=", arr)

	//9.如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)
	arr := [3]int{11, 22, 33}
	test02(&arr)
	fmt.Println("main arr=", arr)

	//10.长度是数组类型的一部分，在传递函数参数时，需要考虑数组的长度,看下面案例:
	//编译错误一：不能把[3]int 传递给[]int   []int是切片
	/*
		func modify(arr []int){
			arr[0] = 100
			fmt.Println("modify的arr",arr)
		}

		func main(){
			var arr = [...]int{1,2,3}
			modify(arr)
		}
	*/

	//编译错误二：不能把[3]int 传递给[4]int
	/*
		func modify(arr[4] int){
			arr[0] = 100
			fmt.Println{"modify 的arr",arr}
		}

		func main(){
			var arr = {...}int{1,2,3}
			modify(arr)
		}
	*/

	//编译错误三:默认值拷贝
	/*
		func modify(arr [3]int){
			arr[0] = 100
			fmt.Println("modify的arr",arr)
		}

		func main(){
			var arr = {...}int{1,2,3}
			modify{arr}
		}
	*/
}
